import { BotApi, AlemonApi, plugin } from '../../model/api/api.js'
import fs from "fs";
import Config from '../../model/Config.js'
import {
    createAGroupFolder,
    deletePlayerData,
    getPlayerData,
    isGroupExist,
    isPlayerExist,
    PLUGIN_PATH,
    storagePlayerData,
    getConfig,
    formatCurrency,
    checkPermission
} from '../../../Slave-Market/function/function.js';

const dirpath = "plugins/akasha-terminal-plugin/data/UserData"; // 文件夹路径
const dirpath2 = "plugins/akasha-terminal-plugin/resources/weapon/weapon.json";
const dirpath3 = "plugins/akasha-terminal-plugin/resources/weaponshop";

// 初始化用户模板
let Template = {
    "money": 0,
    "3": { "num": 0 },
    "4": { "num": 0 },
    "5": { "num": 0 }
};

// 读取武器数据
var weapon = fs.existsSync(dirpath2) ? JSON.parse(fs.readFileSync(dirpath2, "utf8")) : null;
let num3 = weapon ? weapon[`下位武器数量`] : 0;
let num4 = weapon ? weapon[`上位武器数量`] : 0;
let num5 = weapon ? weapon[`大师级武器数量`] : 0;

export class drawcard extends plugin {
    constructor() {
        super({
            /** 功能名称 */
            name: '虚空武器商店',
            /** 功能描述 */
            dsc: '查看和购买武器',
            event: 'message',
            /** 优先级，数字越小等级越高 */
            priority: 1000,
            rule: [
                {
                    /** 命令正则匹配 */
                    reg: "^#购买(下位|上位|大师级)武器[0-9]{1,}$", // 匹配消息正则，命令正则
                    /** 执行方法 */
                    fnc: 'buyWeapon'
                },
                {
                    /** 命令正则匹配 */
                    reg: "^#(下位|上位|大师级)武器商店$", // 匹配消息正则，命令正则
                    /** 执行方法 */
                    fnc: 'weaponWarehouse'
                },
                {
                    /** 命令正则匹配 */
                    reg: "^#我的武器$", // 匹配消息正则，命令正则
                    /** 执行方法 */
                    fnc: 'myweapon'
                }
            ]
        })
    }
    
    /**
     * 武器商店展示
     */
    async weaponWarehouse(e) {
        // 判断是需要的哪种武器商店，是上位、下位还是大师级
        let mess = e.msg.replace("#", "").trim()
        let wq = mess.replace("商店", "").trim()
        const weaponPath = dirpath3 + "/" + wq + ".json"

        // 检查武器商店文件是否存在
        if (!fs.existsSync(weaponPath)) {
            e.reply(`找不到${wq}武器商店数据`);
            return;
        }

        var weaponthing = JSON.parse(fs.readFileSync(weaponPath, "utf8")); // 读取文件
        var msg = []
        msg.push(`【${wq}武器商店】\n欢迎光临，请选择想要购买的武器：`)
        
        for (let i of Object.keys(weaponthing)) {
            msg.push([
                `ID: ${i}\n【${weaponthing[i].name}】\n价格: ${weaponthing[i].value}金币`,
                segment.image(weaponthing[i].url)
            ])
        }
        
        msg.push('购买方式：#购买[武器类型]武器[ID]\n例如：#购买下位武器1')
        Config.getforwardMsg(msg, e)
        return true
    }

    /**
     * 购买武器
     */
    async buyWeapon(e) {
        // 从命令中提取武器类型和ID
        let msg = e.msg.trim();
        let match = msg.match(/^#购买(下位|上位|大师级)武器(\d+)$/);
        if (!match) {
            e.reply('命令格式错误，请使用 #购买[下位/上位/大师级]武器[ID]');
            return;
        }
        
        const weaponType = match[1]; // 武器类型
        const weaponId = match[2];   // 武器ID
        
        // 获取用户数据
        const userData = await getPlayerData(e.group_id, e.user_id);
        const user_id = e.user_id;
        let filename = `${user_id}.json`;
        
        // 创建文件夹（如果不存在）
        if (!fs.existsSync(dirpath)) {
            fs.mkdirSync(dirpath, { recursive: true });
        }
        
        // 读取或创建用户武器数据
        let userWeaponData;
        if (!fs.existsSync(dirpath + "/" + filename)) {
            userWeaponData = JSON.parse(JSON.stringify(Template));
        } else {
            userWeaponData = JSON.parse(fs.readFileSync(dirpath + "/" + filename, "utf8"));
        }
        
        // 读取武器商店数据
        const weaponJsonPath = dirpath3 + "/" + weaponType + "武器.json";
        
        // 检查武器商店文件是否存在
        if (!fs.existsSync(weaponJsonPath)) {
            e.reply(`找不到${weaponType}商店数据`);
            return;
        }
        
        const weaponShop = JSON.parse(fs.readFileSync(weaponJsonPath, "utf8"));
        
        // 检查武器ID是否存在
        if (!weaponShop[weaponId]) {
            e.reply(`ID为${weaponId}的${weaponType}不存在`);
            return;
        }
        
        const weaponItem = weaponShop[weaponId];
        const price = weaponItem.value;
        
        // 检查用户金币是否足够
        if (userData.currency < price) {
            e.reply(`购买【${weaponItem.name}】需要${price}金币，你只有${userData.currency}金币，无法购买！`);
            return;
        }
        
        // 扣除金币
        userData.currency = formatCurrency(userData.currency - price);
        storagePlayerData(e.group_id, e.user_id, userData);
        
        // 添加武器到用户库存
        // 根据武器类型确定星级
        let starRating = 3; // 默认为3星
        if (weaponType === '上位') starRating = 4;
        if (weaponType === '大师级') starRating = 5;
        
        // 确保用户拥有对应星级的武器库
        if (!userWeaponData.hasOwnProperty(starRating)) {
            userWeaponData[starRating] = { num: 0 };
        }
        
        // 添加或增加武器计数
        if (!userWeaponData[starRating].hasOwnProperty(weaponId)) {
            userWeaponData[starRating][weaponId] = 1;
        } else {
            userWeaponData[starRating][weaponId]++;
        }
        
        // 更新武器总数
        userWeaponData[starRating].num = (userWeaponData[starRating].num || 0) + 1;
        
        // 保存用户武器数据
        fs.writeFileSync(dirpath + "/" + filename, JSON.stringify(userWeaponData, null, "\t"));
        
        // 回复购买成功信息
        e.reply([
            `购买成功！你获得了${weaponType}【${weaponItem.name}】`,
            segment.image(weaponItem.url),
            `\n消费了${price}金币，当前剩余${userData.currency}金币`
        ]);
        
        return true;
    }

    /**
     * 查看我的武器
     */
    async myweapon(e) {
        let user_id = e.user_id;
        let filename = `${user_id}.json`;
        
        // 获取用户数据和武器数据
        const userData = await getPlayerData(e.group_id, e.user_id);
        
        // 如果文件不存在，创建文件
        if (!fs.existsSync(dirpath)) {
            fs.mkdirSync(dirpath, { recursive: true });
        }
        
        if (!fs.existsSync(dirpath + "/" + filename)) {
            e.reply(`你还没有任何武器，可以使用 #[武器类型]武器商店 查看并购买武器`);
            // 创建空的武器数据文件
            fs.writeFileSync(dirpath + "/" + filename, JSON.stringify(Template, null, "\t"));
            return;
        }
        
        // 读取文件
        var json = JSON.parse(fs.readFileSync(dirpath + "/" + filename, "utf8"));
        
        // 如果武器数据为空或格式不正确，则修复数据结构
        if (!json.hasOwnProperty('3')) json['3'] = { num: 0 };
        if (!json.hasOwnProperty('4')) json['4'] = { num: 0 };
        if (!json.hasOwnProperty('5')) json['5'] = { num: 0 };
        
        // 重新计算武器总数（修复可能的错误计数）
        json['3'].num = calculateWeaponCount(json['3']);
        json['4'].num = calculateWeaponCount(json['4']);
        json['5'].num = calculateWeaponCount(json['5']);
        
        // 保存更新后的数据
        fs.writeFileSync(dirpath + "/" + filename, JSON.stringify(json, null, "\t"));
        
        // 读取武器商店数据，以获取武器URL
        const weaponShops = {
            '3': loadWeaponShopData('下位'),
            '4': loadWeaponShopData('上位'),
            '5': loadWeaponShopData('大师级')
        };
        
        // 检查是否有任何武器
        const hasWeapons = 
            (json['3'].num > 0) || 
            (json['4'].num > 0) || 
            (json['5'].num > 0);
        
        if (!hasWeapons) {
            e.reply(`你还没有任何武器，可以使用 #[武器类型]武器商店 查看并购买武器`);
            return;
        }
        
        // 使用转发消息的形式展示武器
        var msg = [];
        msg.push(`【${e.sender.card || e.sender.nickname}的武器库】\n当前持有金币：${userData.currency}\n\n武器总览:\n下位武器: ${json['3'].num}把\n上位武器: ${json['4'].num}把\n大师级武器: ${json['5'].num}把`);
        
        // 大师级武器
        if (json['5'].num > 0) {
            msg.push('【大师级武器】');
            for (let i of Object.keys(json['5'])) {
                if (i === 'num') continue;
                
                const weaponItem = weaponShops['5'] ? weaponShops['5'][i] : null;
                if (weaponItem) {
                    msg.push([
                        `${weaponItem.name} (ID:${i})  数量：${json['5'][i]}`,
                        segment.image(weaponItem.url)
                    ]);
                }
            }
        }
        
        // 上位武器
        if (json['4'].num > 0) {
            msg.push('【上位武器】');
            for (let i of Object.keys(json['4'])) {
                if (i === 'num') continue;
                
                const weaponItem = weaponShops['4'] ? weaponShops['4'][i] : null;
                if (weaponItem) {
                    msg.push([
                        `${weaponItem.name} (ID:${i})  数量：${json['4'][i]}`,
                        segment.image(weaponItem.url)
                    ]);
                }
            }
        }
        
        // 下位武器
        if (json['3'].num > 0) {
            msg.push('【下位武器】');
            for (let i of Object.keys(json['3'])) {
                if (i === 'num') continue;
                
                const weaponItem = weaponShops['3'] ? weaponShops['3'][i] : null;
                if (weaponItem) {
                    msg.push([
                        `${weaponItem.name} (ID:${i})  数量：${json['3'][i]}`,
                        segment.image(weaponItem.url)
                    ]);
                }
            }
        }
        
        Config.getforwardMsg(msg, e);
        return true;
    }
}

// 辅助函数：加载武器商店数据
function loadWeaponShopData(type) {
    const filePath = dirpath3 + "/" + type + "武器.json";
    if (fs.existsSync(filePath)) {
        try {
            return JSON.parse(fs.readFileSync(filePath, "utf8"));
        } catch (error) {
            logger.error(`读取${type}武器商店数据失败:`, error);
            return null;
        }
    }
    return null;
}

// 辅助函数：计算武器总数
function calculateWeaponCount(weaponData) {
    let count = 0;
    for (let key in weaponData) {
        if (key !== 'num') {
            count += weaponData[key];
        }
    }
    return count;
}